home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / SearchEngine.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  6.6 KB  |  256 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import re
  5. from Tkinter import *
  6. import tkMessageBox
  7.  
  8. def get(root):
  9.     if not hasattr(root, '_searchengine'):
  10.         root._searchengine = SearchEngine(root)
  11.     
  12.     return root._searchengine
  13.  
  14.  
  15. class SearchEngine:
  16.     
  17.     def __init__(self, root):
  18.         self.root = root
  19.         self.patvar = StringVar(root)
  20.         self.revar = BooleanVar(root)
  21.         self.casevar = BooleanVar(root)
  22.         self.wordvar = BooleanVar(root)
  23.         self.wrapvar = BooleanVar(root)
  24.         self.wrapvar.set(1)
  25.         self.backvar = BooleanVar(root)
  26.  
  27.     
  28.     def getpat(self):
  29.         return self.patvar.get()
  30.  
  31.     
  32.     def setpat(self, pat):
  33.         self.patvar.set(pat)
  34.  
  35.     
  36.     def isre(self):
  37.         return self.revar.get()
  38.  
  39.     
  40.     def iscase(self):
  41.         return self.casevar.get()
  42.  
  43.     
  44.     def isword(self):
  45.         return self.wordvar.get()
  46.  
  47.     
  48.     def iswrap(self):
  49.         return self.wrapvar.get()
  50.  
  51.     
  52.     def isback(self):
  53.         return self.backvar.get()
  54.  
  55.     
  56.     def getcookedpat(self):
  57.         pat = self.getpat()
  58.         if not self.isre():
  59.             pat = re.escape(pat)
  60.         
  61.         if self.isword():
  62.             pat = '\\b%s\\b' % pat
  63.         
  64.         return pat
  65.  
  66.     
  67.     def getprog(self):
  68.         pat = self.getpat()
  69.         if not pat:
  70.             self.report_error(pat, 'Empty regular expression')
  71.             return None
  72.         
  73.         pat = self.getcookedpat()
  74.         flags = 0
  75.         if not self.iscase():
  76.             flags = flags | re.IGNORECASE
  77.         
  78.         
  79.         try:
  80.             prog = re.compile(pat, flags)
  81.         except re.error:
  82.             what = None
  83.             
  84.             try:
  85.                 (msg, col) = what
  86.             except:
  87.                 msg = str(what)
  88.                 col = -1
  89.  
  90.             self.report_error(pat, msg, col)
  91.             return None
  92.  
  93.         return prog
  94.  
  95.     
  96.     def report_error(self, pat, msg, col = -1):
  97.         msg = 'Error: ' + str(msg)
  98.         if pat:
  99.             msg = msg + '\np\\Pattern: ' + str(pat)
  100.         
  101.         if col >= 0:
  102.             msg = msg + '\nOffset: ' + str(col)
  103.         
  104.         tkMessageBox.showerror('Regular expression error', msg, master = self.root)
  105.  
  106.     
  107.     def setcookedpat(self, pat):
  108.         if self.isre():
  109.             pat = re.escape(pat)
  110.         
  111.         self.setpat(pat)
  112.  
  113.     
  114.     def search_text(self, text, prog = None, ok = 0):
  115.         '''Search a text widget for the pattern.
  116.  
  117.         If prog is given, it should be the precompiled pattern.
  118.         Return a tuple (lineno, matchobj); None if not found.
  119.  
  120.         This obeys the wrap and direction (back) settings.
  121.  
  122.         The search starts at the selection (if there is one) or
  123.         at the insert mark (otherwise).  If the search is forward,
  124.         it starts at the right of the selection; for a backward
  125.         search, it starts at the left end.  An empty match exactly
  126.         at either end of the selection (or at the insert mark if
  127.         there is no selection) is ignored  unless the ok flag is true
  128.         -- this is done to guarantee progress.
  129.  
  130.         If the search is allowed to wrap around, it will return the
  131.         original selection if (and only if) it is the only match.
  132.  
  133.         '''
  134.         if not prog:
  135.             prog = self.getprog()
  136.             if not prog:
  137.                 return None
  138.             
  139.         
  140.         wrap = self.wrapvar.get()
  141.         (first, last) = get_selection(text)
  142.         if self.isback():
  143.             if ok:
  144.                 start = last
  145.             else:
  146.                 start = first
  147.             (line, col) = get_line_col(start)
  148.             res = self.search_backward(text, prog, line, col, wrap, ok)
  149.         elif ok:
  150.             start = first
  151.         else:
  152.             start = last
  153.         (line, col) = get_line_col(start)
  154.         res = self.search_forward(text, prog, line, col, wrap, ok)
  155.         return res
  156.  
  157.     
  158.     def search_forward(self, text, prog, line, col, wrap, ok = 0):
  159.         wrapped = 0
  160.         startline = line
  161.         chars = text.get('%d.0' % line, '%d.0' % (line + 1))
  162.         while chars:
  163.             m = prog.search(chars[:-1], col)
  164.             if m:
  165.                 if ok or m.end() > col:
  166.                     return (line, m)
  167.                 
  168.             
  169.             line = line + 1
  170.             if wrapped and line > startline:
  171.                 break
  172.             
  173.             col = 0
  174.             ok = 1
  175.             chars = text.get('%d.0' % line, '%d.0' % (line + 1))
  176.             if not chars and wrap:
  177.                 wrapped = 1
  178.                 wrap = 0
  179.                 line = 1
  180.                 chars = text.get('1.0', '2.0')
  181.                 continue
  182.  
  183.     
  184.     def search_backward(self, text, prog, line, col, wrap, ok = 0):
  185.         wrapped = 0
  186.         startline = line
  187.         chars = text.get('%d.0' % line, '%d.0' % (line + 1))
  188.         while None:
  189.             m = search_reverse(prog, chars[:-1], col)
  190.             if m:
  191.                 if ok or m.start() < col:
  192.                     return (line, m)
  193.                 
  194.             
  195.             line = line - 1
  196.             if wrapped and line < startline:
  197.                 break
  198.             
  199.             ok = 1
  200.             if line <= 0:
  201.                 if not wrap:
  202.                     break
  203.                 
  204.                 wrapped = 1
  205.                 wrap = 0
  206.                 pos = text.index('end-1c')
  207.                 (line, col) = map(int, pos.split('.'))
  208.             
  209.             chars = text.get('%d.0' % line, '%d.0' % (line + 1))
  210.             col = len(chars) - 1
  211.  
  212.  
  213.  
  214. def search_reverse(prog, chars, col):
  215.     m = prog.search(chars)
  216.     if not m:
  217.         return None
  218.     
  219.     found = None
  220.     (i, j) = m.span()
  221.     while i < col and j <= col:
  222.         found = m
  223.         if i == j:
  224.             j = j + 1
  225.         
  226.         m = prog.search(chars, j)
  227.         if not m:
  228.             break
  229.         
  230.         (i, j) = m.span()
  231.     return found
  232.  
  233.  
  234. def get_selection(text):
  235.     
  236.     try:
  237.         first = text.index('sel.first')
  238.         last = text.index('sel.last')
  239.     except TclError:
  240.         first = None
  241.         last = None
  242.  
  243.     if not first:
  244.         first = text.index('insert')
  245.     
  246.     if not last:
  247.         last = first
  248.     
  249.     return (first, last)
  250.  
  251.  
  252. def get_line_col(index):
  253.     (line, col) = map(int, index.split('.'))
  254.     return (line, col)
  255.  
  256.